﻿using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;

namespace Notepad_X.Plugin
{
    public class PluginServices : IPluginHost
    {
        Main main = Notepad_X.Static.MainInstance;
        public PluginServices()
        {
           
        }
        /// <summary>
        /// Available plugins collection
        /// </summary>
        public AvailablePlugins colAvailablePlugins = new AvailablePlugins();

        /// <summary>
        /// A Collection of all Plugins Found and Loaded by the FindPlugins() Method
        /// </summary>
        public AvailablePlugins AvailablePlugins
        {
            get { return colAvailablePlugins; }
            set { colAvailablePlugins = value; }
        }

        /// <summary>
        /// Searches the Application's Startup Directory for Plugins
        /// </summary>
        public void FindPlugins()
        {
            FindPlugins(AppDomain.CurrentDomain.BaseDirectory);
        }
        /// <summary>
        /// Searches the passed Path for Plugins
        /// </summary>
        /// <param name="Path">Directory to search for Plugins in</param>
        public void FindPlugins(string Path)
        {
            //First empty the collection, we're reloading them all
            colAvailablePlugins.Clear();

            //Go through all the files in the plugin directory
            foreach (string fileOn in Directory.GetFiles(Path))
            {
                FileInfo file = new FileInfo(fileOn);

                //Preliminary check, must be .dll
                if (file.Extension.Equals(".dll"))
                {
                    //Add the 'plugin'
                    this.AddPlugin(fileOn);
                }
            }
        }

        /// <summary>
        /// Unloads and Closes all AvailablePlugins
        /// </summary>
        /// 
        public void ClosePlugin(String pluginNameOrPath)
        {
            AvailablePlugin tmp = null; 
            foreach (AvailablePlugin pluginOn in colAvailablePlugins)
            {
                if((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))
                {
                    pluginOn.Instance.Dispose();
                    pluginOn.Instance = null;
                    tmp = pluginOn;
                    break;
                }
               
             }
            if (tmp != null)
            {
                remove(tmp);
            }
     
        }
        private void remove(AvailablePlugin pl)
        {
            colAvailablePlugins.Remove(pl);
        }
        /// <summary>
        /// Close all the plugins
        /// </summary>
        public void ClosePlugins()
        {
            foreach (AvailablePlugin pluginOn in colAvailablePlugins)
            {
                try
                {
                    //Close all plugin instances
                    //We call the plugins Dispose sub first incase it has to do 
                    //Its own cleanup stuff
                    pluginOn.Instance.Dispose();

                    //After we give the plugin a chance to tidy up, get rid of it
                    pluginOn.Instance = null;
                }catch(Exception){
                }
               
            }

            //Finally, clear our collection of available plugins
            colAvailablePlugins.Clear();
        }
        /// <summary>
        /// Reads an toolbar file and returns the properties as array (Name,Author,Version,Description)
        /// </summary>
        /// <returns>String array (Name,Author,Version,Description)</returns>
        /// <param name="FileName">Filename of the plugin</param>
        public string[] hash(string FileName)
        {
            string[] ret = null;
            try
            {
                Assembly pluginAssembly = Assembly.LoadFrom(FileName);
                foreach (Type pluginType in pluginAssembly.GetTypes())
                {
                    if (pluginType.IsPublic)
                    {
                        if (!pluginType.IsAbstract)
                        {
                            Type typeInterface = pluginType.GetInterface("Notepad_X.Plugin.IPlugin", true);

                            if (typeInterface != null)
                            {
                                AvailablePlugin newPlugin = new AvailablePlugin();

                                newPlugin.AssemblyPath = FileName;
                                newPlugin.Instance = (IPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));

                                ret = new string[4];
                                ret[0] = newPlugin.Instance.Name;
                                ret[1] = newPlugin.Instance.Author;
                                ret[2] = newPlugin.Instance.Version;
                                ret[3] = newPlugin.Instance.Description;
                                newPlugin.Instance = null;
                                newPlugin = null;
                            }
                            typeInterface = null;
                        }

                    }
                }
                pluginAssembly = null;
            }
            catch
            {
                ret = null;
            }
            return ret;
        }
        public void AddPlugin(string FileName)
        {
            //Create a new assembly from the plugin file we're adding..
            Assembly pluginAssembly = Assembly.LoadFrom(FileName);
            //Next we'll loop through all the Types found in the assembly
            foreach (Type pluginType in pluginAssembly.GetTypes())
            {
                if (pluginType.IsPublic) //Only look at public types
                {
                    if (!pluginType.IsAbstract)  //Only look at non-abstract types
                    {
                        //Gets a type object of the interface we need the plugins to match
                        Type typeInterface = pluginType.GetInterface("Notepad_X.Plugin.IPlugin", true);

                        //Make sure the interface we want to use actually exists
                        if (typeInterface != null)
                        {
                            //Create a new available plugin since the type implements the IPlugin interface
                            AvailablePlugin newPlugin = new AvailablePlugin();

                            //Set the filename where we found it
                            newPlugin.AssemblyPath = FileName;

                            //Create a new instance and store the instance in the collection for later use
                            //We could change this later on to not load an instance.. we have 2 options
                            //1- Make one instance, and use it whenever we need it.. it's always there
                            //2- Don't make an instance, and instead make an instance whenever we use it, then close it
                            //For now we'll just make an instance of all the plugins
                            newPlugin.Instance = (IPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));

                            //Add the new plugin to our collection here
                            this.colAvailablePlugins.Add(newPlugin);

                            //Call the initialization sub of the plugin
                            newPlugin.Instance.Initialize();

                            //cleanup
                            newPlugin = null;
                        }
                        typeInterface = null; // Clean			
                    }
                }
            }

            pluginAssembly = null; //more cleanup
        }
    }

    public class AvailablePlugins : System.Collections.CollectionBase
	{
		//A Simple class to hold some info about our Available Plugins
		
		/// <summary>
		/// Add a Plugin to the collection of Available plugins
		/// </summary>
		/// <param name="pluginToAdd">The Plugin to Add</param>
		public void Add(AvailablePlugin pluginToAdd)
		{
			this.List.Add(pluginToAdd); 
		}
        public string get(int id)
        {
           return ((AvailablePlugin)this.List[id]).AssemblyPath;
        }
		/// <summary>
		/// Remove a Plugin to the collection of Available plugins
		/// </summary>
		/// <param name="pluginToRemove">The Plugin to Remove</param>
		public void Remove(AvailablePlugin pluginToRemove)
		{
			this.List.Remove(pluginToRemove);
            pluginToRemove = null;
		}
        public bool Exist(string pluginNameOrPath)
        {
            foreach (AvailablePlugin pluginOn in this.List)
            {
                try
                {
                    if ((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))
                    {
                        return true;
                    }
                }
                catch { }
            }
            return false;
        }

		/// <summary>
		/// Finds a plugin in the available Plugins
		/// </summary>
		/// <param name="pluginNameOrPath">The name or File path of the plugin to find</param>
		/// <returns>Available Plugin, or null if the plugin is not found</returns>
		public AvailablePlugin Find(string pluginNameOrPath)
		{
			//Loop through all the plugins
			foreach (AvailablePlugin pluginOn in this.List)
			{
                try
                {
                    //Find the one with the matching name or filename
                    if ((pluginOn.Instance.Name.Equals(pluginNameOrPath)) || pluginOn.AssemblyPath.Equals(pluginNameOrPath))
                    {
                        return pluginOn;                        
                    }
                }
                catch { }
			}
			return null;
		}
	}
	
	/// <summary>
	/// Data Class for Available Plugin.  Holds and instance of the loaded Plugin, as well as the Plugin's Assembly Path
	/// </summary>
	public class AvailablePlugin
	{
		//This is the actual AvailablePlugin object.. 
		//Holds an instance of the plugin to access
		//Also holds assembly path
		private IPlugin myInstance = null;
		private string myAssemblyPath = "";
		
		public IPlugin Instance
		{
			get {return myInstance;}
			set	{myInstance = value;}
		}
		public string AssemblyPath
		{
			get {return myAssemblyPath;}
			set {myAssemblyPath = value;}
		}
	}
}	

